const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');

// 分类模型定义
const Category = sequelize.define('Category', {
  // 主键ID
  id: {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true,
    allowNull: false
  },
  
  // 分类名称
  name: {
    type: DataTypes.STRING(50),
    allowNull: false,
    unique: true,
    validate: {
      notEmpty: {
        msg: '分类名称不能为空'
      },
      len: {
        args: [1, 50],
        msg: '分类名称长度必须在1-50个字符之间'
      }
    }
  },
  
  // 分类图标
  icon: {
    type: DataTypes.STRING(255),
    allowNull: true
  },
  
  // 父分类ID（用于构建分类层级）
  parent_id: {
    type: DataTypes.INTEGER,
    allowNull: true,
    defaultValue: null,
    references: {
      model: 'categories',
      key: 'id'
    }
  },
  
  // 排序权重
  sort_order: {
    type: DataTypes.INTEGER,
    allowNull: false,
    defaultValue: 0,
    validate: {
      min: 0
    }
  },
  
  // 分类描述
  description: {
    type: DataTypes.TEXT,
    allowNull: true
  },
  
  // 状态（0: 禁用, 1: 启用）
  status: {
    type: DataTypes.TINYINT,
    allowNull: false,
    defaultValue: 1,
    validate: {
      isIn: {
        args: [[0, 1]],
        msg: '状态值无效'
      }
    }
  },
  
  // 创建时间
  createdAt: {
    type: DataTypes.DATE,
    allowNull: false,
    defaultValue: DataTypes.NOW
  },
  
  // 更新时间
  updatedAt: {
    type: DataTypes.DATE,
    allowNull: false,
    defaultValue: DataTypes.NOW
  },
  
  // 删除时间（软删除）
  deletedAt: {
    type: DataTypes.DATE,
    allowNull: true
  }
}, {
  // 表配置
  tableName: 'categories',
  timestamps: true,
  paranoid: false, // 禁用软删除
  underscored: true, // 使用下划线命名
  charset: 'utf8mb4',
  collate: 'utf8mb4_unicode_ci'
});

// 自关联：分类可以有父分类和子分类
Category.belongsTo(Category, { foreignKey: 'parent_id', as: 'parent' });
Category.hasMany(Category, { foreignKey: 'parent_id', as: 'children' });

// 类方法：获取所有启用的分类
Category.getAllActiveCategories = async function(includeChildren = false) {
  const query = {
    where: {
      status: 1
    },
    order: [['sort_order', 'ASC'], ['id', 'ASC']]
  };
  
  if (includeChildren) {
    query.include = [
      {
        model: Category,
        as: 'children',
        where: { status: 1 },
        required: false,
        order: [['sort_order', 'ASC'], ['id', 'ASC']]
      }
    ];
  }
  
  return await this.findAll(query);
};

// 类方法：获取顶级分类（没有父分类的分类）
Category.getTopCategories = async function() {
  return await this.findAll({
    where: {
      parent_id: null,
      status: 1
    },
    order: [['sort_order', 'ASC'], ['id', 'ASC']],
    include: [
      {
        model: Category,
        as: 'children',
        where: { status: 1 },
        required: false,
        order: [['sort_order', 'ASC'], ['id', 'ASC']]
      }
    ]
  });
};

// 类方法：获取指定分类下的所有子分类（包括多级）
Category.getSubCategoriesRecursive = async function(categoryId) {
  const getChildren = async (parentId) => {
    const children = await this.findAll({
      where: {
        parent_id: parentId,
        status: 1
      }
    });
    
    for (const child of children) {
      child.dataValues.children = await getChildren(child.id);
    }
    
    return children;
  };
  
  return await getChildren(categoryId);
};

// 类方法：获取分类树结构
Category.getCategoryTree = async function() {
  // 获取所有启用的顶级分类
  const topCategories = await this.findAll({
    where: {
      parent_id: null,
      status: 1
    },
    order: [['sort_order', 'ASC'], ['id', 'ASC']]
  });

  // 递归构建分类树
  const buildTree = async (categories) => {
    for (const category of categories) {
      const children = await this.findAll({
        where: {
          parent_id: category.id,
          status: 1
        },
        order: [['sort_order', 'ASC'], ['id', 'ASC']]
      });
      
      if (children.length > 0) {
        category.dataValues.children = await buildTree(children);
      } else {
        category.dataValues.children = [];
      }
    }
    return categories;
  };

  return await buildTree(topCategories);
};

module.exports = Category;

// 导出到全局，方便其他模块使用
global.Category = Category;